using UnityEngine;
using System.Collections.Generic;
using Unity.Netcode;

namespace Since.Netcode
{
    public class NetcodeTransformNonAuthority : INetworkNonAuthority<NetcodeTransform>
    {
        // 平滑移动参数
        private float smoothTime = 0.1f; // 平滑时间
        private Vector3 currentVelocity = Vector3.zero; // 当前速度（用于平滑）

        // 位置相关参数
        private Vector3 networkPosition; // 从网络接收的位置
        private Vector3 simulatedPosition; // 本地模拟的位置

        // 校正参数
        private bool needsCorrection = false; // 是否需要位置校正
        private float correctionStartTime = 0f; // 校正开始时间
        private float correctionDuration = 0.1f; // 校正持续时间
        private Vector3 correctionStartPosition; // 校正开始位置
        private Vector3 correctionTargetPosition; // 校正目标位置

        // 预测系统
        private Vector3 networkVelocity = Vector3.zero; // 从网络接收的速度

        public override void OnNetworkSpawn()
        {
            // 初始化位置
            networkPosition = owner.transform.position;
            simulatedPosition = owner.transform.position;

            // 初始化速度
            networkVelocity = owner.NetworkVelocity;

            // 监听位置变化
            owner._Position.OnValueChanged += OnPositionChanged;

            // 监听速度变化
            owner._Velocity.OnValueChanged += OnVelocityChanged;
        }

        private void OnPositionChanged(Vector2 oldValue, Vector2 newValue)
        {
            Vector3 newPosition = new Vector3(newValue.x, newValue.y, 0f);
            OnPositonValueChange(newPosition);
        }

        private void OnVelocityChanged(Vector2 oldValue, Vector2 newValue)
        {
            Vector3 newVelocity = new Vector3(newValue.x, newValue.y, 0f);
            OnVelocityValueChange(newVelocity);
        }

        public void OnVelocityValueChange(Vector3 velocity)
        {
            // 更新网络速度
            networkVelocity = velocity;

            // 立即应用到当前速度，确保连续运动
            if (!needsCorrection)
            {
                currentVelocity = networkVelocity;
            }
        }

        public void OnPositonValueChange(Vector3 position)
        {
            // 更新网络位置
            networkPosition = position;

            // 计算当前模拟位置与网络位置的误差
            float positionError = Vector3.Distance(simulatedPosition, networkPosition);

            // 如果误差超过阈值，开始校正
            if (positionError > owner.positionErrorThreshold)
            {
                StartCorrection(networkPosition);
            }
        }

        // 开始校正过程
        private void StartCorrection(Vector3 targetPosition)
        {
            // 设置校正标志
            needsCorrection = true;

            // 记录校正开始时间和位置
            correctionStartTime = Time.time;
            correctionStartPosition = simulatedPosition;

            // 计算校正目标位置（考虑网络速度）
            correctionTargetPosition = targetPosition + networkVelocity * correctionDuration * 0.5f;

            correctionDuration = 0.01f;
            smoothTime = 0.01f;
        }

        public override void Update()
        {
            float deltaTime = Time.deltaTime;

            if (needsCorrection && owner.useSmoothing)
            {
                // 计算校正进度（0-1）
                float correctionProgress = Mathf.Clamp01((Time.time - correctionStartTime) / correctionDuration);

                // 更新校正目标位置（考虑连续移动）
                Vector3 updatedTargetPosition = correctionTargetPosition + networkVelocity * deltaTime;

                if (correctionProgress < 1.0f)
                {
                    // 校正过程中
                    if (owner.useSmoothing)
                    {
                        // 使用SmoothDamp进行平滑校正
                        simulatedPosition = Vector3.SmoothDamp(
                            simulatedPosition,
                            updatedTargetPosition,
                            ref currentVelocity,
                            smoothTime);
                    }
                    else
                    {
                        // 不使用平滑，直接Lerp
                        simulatedPosition = Vector3.Lerp(
                            correctionStartPosition,
                            updatedTargetPosition,
                            correctionProgress);
                    }
                }
                else
                {
                    // 校正完成
                    needsCorrection = false;

                    // 确保速度匹配网络速度
                    currentVelocity = networkVelocity;
                }
            }
            else
            {
                // 正常移动模式，直接使用网络速度
                simulatedPosition += networkVelocity * deltaTime;
            }


            // 更新游戏对象位置
            owner.transform.position = simulatedPosition;
        }
    }
}